//
// Created by yanhai on 2020/3/31.
//

#include <iostream>

using namespace std;

class Complex {
public:
    Complex() = default;

    Complex(int re, int im) : re(re), im(im)
    {
        cout << "构造函数" << endl;
    }

    ~Complex()
    {
        cout << "析构函数" << endl;
    }

private:
    int re, im;
};

void test1()
{
    Complex *pc = new Complex(1, 2);
    /**
     * 编译器将上面的代码转化为：
     * void *mem = operator new(sizeof(Complex));   // operator new函数内部调用malloc进行分配内存
     * Complex *pc = static_cast<Complex *>(mem);   // 类型转换
     * pc->Complex::Complex(1, 2);                  // 构造函数
     */

    delete pc;
    /**
     * 编译器转化为：
     *  Complex::~Complex(pc);  // 析构函数
     *  operator delete(ps);    // 释放内存
     */
    cout << "===============" << endl;
}

void test2()
{
    Complex *p = new Complex[3];
    delete[] p;
    /**
     * delete [] p; 唤起3次析构函数
     * delete p; 只会唤起1次析构函数
     *
     * new Complex[3] 申请的内存都会被完整释放，但是由于delete p只调用了1次析构函数，
     * 将会导致有些类内指针申请的内存没有被释放，导致内存泄漏。
     */
}

int main()
{
    test1();
    test2();
    return 0;
}
